/* PrismJS 1.16.0
https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+markup-templating+elm&plugins=line-highlight+file-highlight+toolbar+jsonp-highlight+highlight-keywords+previewers+autoloader+unescaped-markup+normalize-whitespace+keep-markup+show-language */
var _self = "undefined" != typeof window ? window : "undefined" != typeof WorkerGlobalScope && self instanceof WorkerGlobalScope ? self : {},
    Prism = function (g) {
        var c = /\blang(?:uage)?-([\w-]+)\b/i, a = 0, C = {
            manual: g.Prism && g.Prism.manual,
            disableWorkerMessageHandler: g.Prism && g.Prism.disableWorkerMessageHandler,
            util: {
                encode: function (e) {
                    return e instanceof M ? new M(e.type, C.util.encode(e.content), e.alias) : Array.isArray(e) ? e.map(C.util.encode) : e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ")
                }, type: function (e) {
                    return Object.prototype.toString.call(e).slice(8, -1)
                }, objId: function (e) {
                    return e.__id || Object.defineProperty(e, "__id", {value: ++a}), e.__id
                }, clone: function t(e, n) {
                    var r, a, i = C.util.type(e);
                    switch (n = n || {}, i) {
                        case"Object":
                            if (a = C.util.objId(e), n[a]) return n[a];
                            for (var l in r = {}, n[a] = r, e) e.hasOwnProperty(l) && (r[l] = t(e[l], n));
                            return r;
                        case"Array":
                            return a = C.util.objId(e), n[a] ? n[a] : (r = [], n[a] = r, e.forEach(function (e, a) {
                                r[a] = t(e, n)
                            }), r);
                        default:
                            return e
                    }
                }
            },
            languages: {
                extend: function (e, a) {
                    var t = C.util.clone(C.languages[e]);
                    for (var n in a) t[n] = a[n];
                    return t
                }, insertBefore: function (t, e, a, n) {
                    var r = (n = n || C.languages)[t], i = {};
                    for (var l in r) if (r.hasOwnProperty(l)) {
                        if (l == e) for (var o in a) a.hasOwnProperty(o) && (i[o] = a[o]);
                        a.hasOwnProperty(l) || (i[l] = r[l])
                    }
                    var s = n[t];
                    return n[t] = i, C.languages.DFS(C.languages, function (e, a) {
                        a === s && e != t && (this[e] = i)
                    }), i
                }, DFS: function e(a, t, n, r) {
                    r = r || {};
                    var i = C.util.objId;
                    for (var l in a) if (a.hasOwnProperty(l)) {
                        t.call(a, l, a[l], n || l);
                        var o = a[l], s = C.util.type(o);
                        "Object" !== s || r[i(o)] ? "Array" !== s || r[i(o)] || (r[i(o)] = !0, e(o, t, l, r)) : (r[i(o)] = !0, e(o, t, null, r))
                    }
                }
            },
            plugins: {},
            highlightAll: function (e, a) {
                C.highlightAllUnder(document, e, a)
            },
            highlightAllUnder: function (e, a, t) {
                var n = {
                    callback: t,
                    selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
                };
                C.hooks.run("before-highlightall", n);
                for (var r, i = n.elements || e.querySelectorAll(n.selector), l = 0; r = i[l++];) C.highlightElement(r, !0 === a, n.callback)
            },
            highlightElement: function (e, a, t) {
                for (var n, r, i = e; i && !c.test(i.className);) i = i.parentNode;
                i && (n = (i.className.match(c) || [, ""])[1].toLowerCase(), r = C.languages[n]), e.className = e.className.replace(c, "").replace(/\s+/g, " ") + " language-" + n, e.parentNode && (i = e.parentNode, /pre/i.test(i.nodeName) && (i.className = i.className.replace(c, "").replace(/\s+/g, " ") + " language-" + n));
                var l = {element: e, language: n, grammar: r, code: e.textContent}, o = function (e) {
                    l.highlightedCode = e, C.hooks.run("before-insert", l), l.element.innerHTML = l.highlightedCode, C.hooks.run("after-highlight", l), C.hooks.run("complete", l), t && t.call(l.element)
                };
                if (C.hooks.run("before-sanity-check", l), l.code) if (C.hooks.run("before-highlight", l), l.grammar) if (a && g.Worker) {
                    var s = new Worker(C.filename);
                    s.onmessage = function (e) {
                        o(e.data)
                    }, s.postMessage(JSON.stringify({language: l.language, code: l.code, immediateClose: !0}))
                } else o(C.highlight(l.code, l.grammar, l.language)); else o(C.util.encode(l.code)); else C.hooks.run("complete", l)
            },
            highlight: function (e, a, t) {
                var n = {code: e, grammar: a, language: t};
                return C.hooks.run("before-tokenize", n), n.tokens = C.tokenize(n.code, n.grammar), C.hooks.run("after-tokenize", n), M.stringify(C.util.encode(n.tokens), n.language)
            },
            matchGrammar: function (e, a, t, n, r, i, l) {
                for (var o in t) if (t.hasOwnProperty(o) && t[o]) {
                    if (o == l) return;
                    var s = t[o];
                    s = "Array" === C.util.type(s) ? s : [s];
                    for (var g = 0; g < s.length; ++g) {
                        var c = s[g], u = c.inside, h = !!c.lookbehind, f = !!c.greedy, d = 0, m = c.alias;
                        if (f && !c.pattern.global) {
                            var p = c.pattern.toString().match(/[imuy]*$/)[0];
                            c.pattern = RegExp(c.pattern.source, p + "g")
                        }
                        c = c.pattern || c;
                        for (var y = n, v = r; y < a.length; v += a[y].length, ++y) {
                            var k = a[y];
                            if (a.length > e.length) return;
                            if (!(k instanceof M)) {
                                if (f && y != a.length - 1) {
                                    if (c.lastIndex = v, !(x = c.exec(e))) break;
                                    for (var b = x.index + (h ? x[1].length : 0), w = x.index + x[0].length, A = y, P = v, O = a.length; A < O && (P < w || !a[A].type && !a[A - 1].greedy); ++A) (P += a[A].length) <= b && (++y, v = P);
                                    if (a[y] instanceof M) continue;
                                    N = A - y, k = e.slice(v, P), x.index -= v
                                } else {
                                    c.lastIndex = 0;
                                    var x = c.exec(k), N = 1
                                }
                                if (x) {
                                    h && (d = x[1] ? x[1].length : 0);
                                    w = (b = x.index + d) + (x = x[0].slice(d)).length;
                                    var j = k.slice(0, b), S = k.slice(w), E = [y, N];
                                    j && (++y, v += j.length, E.push(j));
                                    var _ = new M(o, u ? C.tokenize(x, u) : x, m, x, f);
                                    if (E.push(_), S && E.push(S), Array.prototype.splice.apply(a, E), 1 != N && C.matchGrammar(e, a, t, y, v, !0, o), i) break
                                } else if (i) break
                            }
                        }
                    }
                }
            },
            tokenize: function (e, a) {
                var t = [e], n = a.rest;
                if (n) {
                    for (var r in n) a[r] = n[r];
                    delete a.rest
                }
                return C.matchGrammar(e, t, a, 0, 0, !1), t
            },
            hooks: {
                all: {}, add: function (e, a) {
                    var t = C.hooks.all;
                    t[e] = t[e] || [], t[e].push(a)
                }, run: function (e, a) {
                    var t = C.hooks.all[e];
                    if (t && t.length) for (var n, r = 0; n = t[r++];) n(a)
                }
            },
            Token: M
        };

        function M(e, a, t, n, r) {
            this.type = e, this.content = a, this.alias = t, this.length = 0 | (n || "").length, this.greedy = !!r
        }

        if (g.Prism = C, M.stringify = function (e, a) {
            if ("string" == typeof e) return e;
            if (Array.isArray(e)) return e.map(function (e) {
                return M.stringify(e, a)
            }).join("");
            var t = {
                type: e.type,
                content: M.stringify(e.content, a),
                tag: "span",
                classes: ["token", e.type],
                attributes: {},
                language: a
            };
            if (e.alias) {
                var n = Array.isArray(e.alias) ? e.alias : [e.alias];
                Array.prototype.push.apply(t.classes, n)
            }
            C.hooks.run("wrap", t);
            var r = Object.keys(t.attributes).map(function (e) {
                return e + '="' + (t.attributes[e] || "").replace(/"/g, "&quot;") + '"'
            }).join(" ");
            return "<" + t.tag + ' class="' + t.classes.join(" ") + '"' + (r ? " " + r : "") + ">" + t.content + "</" + t.tag + ">"
        }, !g.document) return g.addEventListener && (C.disableWorkerMessageHandler || g.addEventListener("message", function (e) {
            var a = JSON.parse(e.data), t = a.language, n = a.code, r = a.immediateClose;
            g.postMessage(C.highlight(n, C.languages[t], t)), r && g.close()
        }, !1)), C;
        var e = document.currentScript || [].slice.call(document.getElementsByTagName("script")).pop();
        return e && (C.filename = e.src, C.manual || e.hasAttribute("data-manual") || ("loading" !== document.readyState ? window.requestAnimationFrame ? window.requestAnimationFrame(C.highlightAll) : window.setTimeout(C.highlightAll, 16) : document.addEventListener("DOMContentLoaded", C.highlightAll))), C
    }(_self);
"undefined" != typeof module && module.exports && (module.exports = Prism), "undefined" != typeof global && (global.Prism = Prism);
Prism.languages.markup = {
    comment: /<!--[\s\S]*?-->/,
    prolog: /<\?[\s\S]+?\?>/,
    doctype: /<!DOCTYPE[\s\S]+?>/i,
    cdata: /<!\[CDATA\[[\s\S]*?]]>/i,
    tag: {
        pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/i,
        greedy: !0,
        inside: {
            tag: {pattern: /^<\/?[^\s>\/]+/i, inside: {punctuation: /^<\/?/, namespace: /^[^\s>\/:]+:/}},
            "attr-value": {
                pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/i,
                inside: {punctuation: [/^=/, {pattern: /^(\s*)["']|["']$/, lookbehind: !0}]}
            },
            punctuation: /\/?>/,
            "attr-name": {pattern: /[^\s>\/]+/, inside: {namespace: /^[^\s>\/:]+:/}}
        }
    },
    entity: /&#?[\da-z]{1,8};/i
}, Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity, Prism.hooks.add("wrap", function (a) {
    "entity" === a.type && (a.attributes.title = a.content.replace(/&amp;/, "&"))
}), Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
    value: function (a, e) {
        var s = {};
        s["language-" + e] = {
            pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
            lookbehind: !0,
            inside: Prism.languages[e]
        }, s.cdata = /^<!\[CDATA\[|\]\]>$/i;
        var n = {"included-cdata": {pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: s}};
        n["language-" + e] = {pattern: /[\s\S]+/, inside: Prism.languages[e]};
        var i = {};
        i[a] = {
            pattern: RegExp("(<__[\\s\\S]*?>)(?:<!\\[CDATA\\[[\\s\\S]*?\\]\\]>\\s*|[\\s\\S])*?(?=<\\/__>)".replace(/__/g, a), "i"),
            lookbehind: !0,
            greedy: !0,
            inside: n
        }, Prism.languages.insertBefore("markup", "cdata", i)
    }
}), Prism.languages.xml = Prism.languages.extend("markup", {}), Prism.languages.html = Prism.languages.markup, Prism.languages.mathml = Prism.languages.markup, Prism.languages.svg = Prism.languages.markup;
!function (s) {
    var e = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
    s.languages.css = {
        comment: /\/\*[\s\S]*?\*\//,
        atrule: {pattern: /@[\w-]+?[\s\S]*?(?:;|(?=\s*\{))/i, inside: {rule: /@[\w-]+/}},
        url: RegExp("url\\((?:" + e.source + "|.*?)\\)", "i"),
        selector: RegExp("[^{}\\s](?:[^{};\"']|" + e.source + ")*?(?=\\s*\\{)"),
        string: {pattern: e, greedy: !0},
        property: /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
        important: /!important\b/i,
        function: /[-a-z0-9]+(?=\()/i,
        punctuation: /[(){};:,]/
    }, s.languages.css.atrule.inside.rest = s.languages.css;
    var a = s.languages.markup;
    a && (a.tag.addInlined("style", "css"), s.languages.insertBefore("inside", "attr-value", {
        "style-attr": {
            pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
            inside: {
                "attr-name": {pattern: /^\s*style/i, inside: a.tag.inside},
                punctuation: /^\s*=\s*['"]|['"]\s*$/,
                "attr-value": {pattern: /.+/i, inside: s.languages.css}
            },
            alias: "language-css"
        }
    }, a.tag))
}(Prism);
Prism.languages.clike = {
    comment: [{
        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
        lookbehind: !0
    }, {pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0}],
    string: {pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: !0},
    "class-name": {
        pattern: /((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,
        lookbehind: !0,
        inside: {punctuation: /[.\\]/}
    },
    keyword: /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
    boolean: /\b(?:true|false)\b/,
    function: /\w+(?=\()/,
    number: /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,
    operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
    punctuation: /[{}[\];(),.:]/
};
Prism.languages.javascript = Prism.languages.extend("clike", {
    "class-name": [Prism.languages.clike["class-name"], {
        pattern: /(^|[^$\w\xA0-\uFFFF])[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/,
        lookbehind: !0
    }],
    keyword: [{
        pattern: /((?:^|})\s*)(?:catch|finally)\b/,
        lookbehind: !0
    }, {
        pattern: /(^|[^.])\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
        lookbehind: !0
    }],
    number: /\b(?:(?:0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+)n?|\d+n|NaN|Infinity)\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][+-]?\d+)?/,
    function: /[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
    operator: /-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/
}), Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/, Prism.languages.insertBefore("javascript", "keyword", {
    regex: {
        pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})\]]))/,
        lookbehind: !0,
        greedy: !0
    },
    "function-variable": {
        pattern: /[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/,
        alias: "function"
    },
    parameter: [{
        pattern: /(function(?:\s+[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)?\s*\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\))/,
        lookbehind: !0,
        inside: Prism.languages.javascript
    }, {
        pattern: /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=>)/i,
        inside: Prism.languages.javascript
    }, {
        pattern: /(\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*=>)/,
        lookbehind: !0,
        inside: Prism.languages.javascript
    }, {
        pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*)\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*\{)/,
        lookbehind: !0,
        inside: Prism.languages.javascript
    }],
    constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
}), Prism.languages.insertBefore("javascript", "string", {
    "template-string": {
        pattern: /`(?:\\[\s\S]|\${[^}]+}|[^\\`])*`/,
        greedy: !0,
        inside: {
            interpolation: {
                pattern: /\${[^}]+}/,
                inside: {
                    "interpolation-punctuation": {pattern: /^\${|}$/, alias: "punctuation"},
                    rest: Prism.languages.javascript
                }
            }, string: /[\s\S]+/
        }
    }
}), Prism.languages.markup && Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.js = Prism.languages.javascript;
!function (h) {
    function v(e, n) {
        return "___" + e.toUpperCase() + n + "___"
    }

    Object.defineProperties(h.languages["markup-templating"] = {}, {
        buildPlaceholders: {
            value: function (a, r, e, o) {
                if (a.language === r) {
                    var c = a.tokenStack = [];
                    a.code = a.code.replace(e, function (e) {
                        if ("function" == typeof o && !o(e)) return e;
                        for (var n, t = c.length; -1 !== a.code.indexOf(n = v(r, t));) ++t;
                        return c[t] = e, n
                    }), a.grammar = h.languages.markup
                }
            }
        }, tokenizePlaceholders: {
            value: function (p, k) {
                if (p.language === k && p.tokenStack) {
                    p.grammar = h.languages[k];
                    var m = 0, d = Object.keys(p.tokenStack);
                    !function e(n) {
                        for (var t = 0; t < n.length && !(m >= d.length); t++) {
                            var a = n[t];
                            if ("string" == typeof a || a.content && "string" == typeof a.content) {
                                var r = d[m], o = p.tokenStack[r], c = "string" == typeof a ? a : a.content,
                                    i = v(k, r), u = c.indexOf(i);
                                if (-1 < u) {
                                    ++m;
                                    var g = c.substring(0, u),
                                        l = new h.Token(k, h.tokenize(o, p.grammar), "language-" + k, o),
                                        s = c.substring(u + i.length), f = [];
                                    g && f.push.apply(f, e([g])), f.push(l), s && f.push.apply(f, e([s])), "string" == typeof a ? n.splice.apply(n, [t, 1].concat(f)) : a.content = f
                                }
                            } else a.content && e(a.content)
                        }
                        return n
                    }(p.tokens)
                }
            }
        }
    })
}(Prism);
Prism.languages.elm = {
    comment: /--.*|{-[\s\S]*?-}/,
    char: {pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+))'/, greedy: !0},
    string: [{
        pattern: /"""[\s\S]*?"""/,
        greedy: !0
    }, {pattern: /"(?:[^\\"\r\n]|\\(?:[abfnrtv\\"]|\d+|x[0-9a-fA-F]+))*"/, greedy: !0}],
    import_statement: {
        pattern: /^\s*import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+([A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
        inside: {keyword: /\b(?:import|as|exposing)\b/}
    },
    keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
    builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
    number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
    operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
    hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
    constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
    punctuation: /[{}[\]|(),.:]/
};
!function () {
    if ("undefined" != typeof self && self.Prism && self.document && document.querySelector) {
        var t, h = function () {
            if (void 0 === t) {
                var e = document.createElement("div");
                e.style.fontSize = "13px", e.style.lineHeight = "1.5", e.style.padding = 0, e.style.border = 0, e.innerHTML = "&nbsp;<br />&nbsp;", document.body.appendChild(e), t = 38 === e.offsetHeight, document.body.removeChild(e)
            }
            return t
        }, l = 0;
        Prism.hooks.add("before-sanity-check", function (e) {
            var t = e.element.parentNode, n = t && t.getAttribute("data-line");
            if (t && n && /pre/i.test(t.nodeName)) {
                var i = 0;
                r(".line-highlight", t).forEach(function (e) {
                    i += e.textContent.length, e.parentNode.removeChild(e)
                }), i && /^( \n)+$/.test(e.code.slice(-i)) && (e.code = e.code.slice(0, -i))
            }
        }), Prism.hooks.add("complete", function e(t) {
            var n = t.element.parentNode, i = n && n.getAttribute("data-line");
            if (n && i && /pre/i.test(n.nodeName)) {
                clearTimeout(l);
                var r = Prism.plugins.lineNumbers, o = t.plugins && t.plugins.lineNumbers;
                g(n, "line-numbers") && r && !o ? Prism.hooks.add("line-numbers", e) : (a(n, i), l = setTimeout(s, 1))
            }
        }), window.addEventListener("hashchange", s), window.addEventListener("resize", function () {
            var e = document.querySelectorAll("pre[data-line]");
            Array.prototype.forEach.call(e, function (e) {
                a(e)
            })
        })
    }

    function r(e, t) {
        return Array.prototype.slice.call((t || document).querySelectorAll(e))
    }

    function g(e, t) {
        return t = " " + t + " ", -1 < (" " + e.className + " ").replace(/[\n\t]/g, " ").indexOf(t)
    }

    function a(e, t, n) {
        for (var i, r = (t = "string" == typeof t ? t : e.getAttribute("data-line")).replace(/\s+/g, "").split(","), o = +e.getAttribute("data-line-offset") || 0, l = (h() ? parseInt : parseFloat)(getComputedStyle(e).lineHeight), a = g(e, "line-numbers"), s = 0; i = r[s++];) {
            var d = i.split("-"), u = +d[0], c = +d[1] || u,
                m = e.querySelector('.line-highlight[data-range="' + i + '"]') || document.createElement("div");
            if (m.setAttribute("aria-hidden", "true"), m.setAttribute("data-range", i), m.className = (n || "") + " line-highlight", a && Prism.plugins.lineNumbers) {
                var p = Prism.plugins.lineNumbers.getLine(e, u), f = Prism.plugins.lineNumbers.getLine(e, c);
                p && (m.style.top = p.offsetTop + "px"), f && (m.style.height = f.offsetTop - p.offsetTop + f.offsetHeight + "px")
            } else m.setAttribute("data-start", u), u < c && m.setAttribute("data-end", c), m.style.top = (u - o - 1) * l + "px", m.textContent = new Array(c - u + 2).join(" \n");
            a ? e.appendChild(m) : (e.querySelector("code") || e).appendChild(m)
        }
    }

    function s() {
        var e = location.hash.slice(1);
        r(".temporary.line-highlight").forEach(function (e) {
            e.parentNode.removeChild(e)
        });
        var t = (e.match(/\.([\d,-]+)$/) || [, ""])[1];
        if (t && !document.getElementById(e)) {
            var n = e.slice(0, e.lastIndexOf(".")), i = document.getElementById(n);
            i && (i.hasAttribute("data-line") || i.setAttribute("data-line", ""), a(i, t, "temporary "), document.querySelector(".temporary.line-highlight").scrollIntoView())
        }
    }
}();
"undefined" != typeof self && self.Prism && self.document && document.querySelector && (self.Prism.fileHighlight = function (t) {
    t = t || document;
    var i = {
        js: "javascript",
        py: "python",
        rb: "ruby",
        ps1: "powershell",
        psm1: "powershell",
        sh: "bash",
        bat: "batch",
        h: "c",
        tex: "latex"
    };
    Array.prototype.slice.call(t.querySelectorAll("pre[data-src]")).forEach(function (t) {
        if (!t.hasAttribute("data-src-loaded")) {
            for (var e, a = t.getAttribute("data-src"), n = t, r = /\blang(?:uage)?-([\w-]+)\b/i; n && !r.test(n.className);) n = n.parentNode;
            if (n && (e = (t.className.match(r) || [, ""])[1]), !e) {
                var s = (a.match(/\.(\w+)$/) || [, ""])[1];
                e = i[s] || s
            }
            var o = document.createElement("code");
            o.className = "language-" + e, t.textContent = "", o.textContent = "Loading…", t.appendChild(o);
            var l = new XMLHttpRequest;
            l.open("GET", a, !0), l.onreadystatechange = function () {
                4 == l.readyState && (l.status < 400 && l.responseText ? (o.textContent = l.responseText, Prism.highlightElement(o), t.setAttribute("data-src-loaded", "")) : 400 <= l.status ? o.textContent = "✖ Error " + l.status + " while fetching file: " + l.statusText : o.textContent = "✖ Error: File does not exist or is empty")
            }, l.send(null)
        }
    }), Prism.plugins.toolbar && Prism.plugins.toolbar.registerButton("download-file", function (t) {
        var e = t.element.parentNode;
        if (e && /pre/i.test(e.nodeName) && e.hasAttribute("data-src") && e.hasAttribute("data-download-link")) {
            var a = e.getAttribute("data-src"), n = document.createElement("a");
            return n.textContent = e.getAttribute("data-download-link-label") || "Download", n.setAttribute("download", ""), n.href = a, n
        }
    })
}, document.addEventListener("DOMContentLoaded", function () {
    self.Prism.fileHighlight()
}));
!function () {
    if ("undefined" != typeof self && self.Prism && self.document) {
        var r = [], i = {}, n = function () {
        };
        Prism.plugins.toolbar = {};
        var t = Prism.plugins.toolbar.registerButton = function (t, n) {
            var e;
            e = "function" == typeof n ? n : function (t) {
                var e;
                return "function" == typeof n.onClick ? ((e = document.createElement("button")).type = "button", e.addEventListener("click", function () {
                    n.onClick.call(this, t)
                })) : "string" == typeof n.url ? (e = document.createElement("a")).href = n.url : e = document.createElement("span"), e.textContent = n.text, e
            }, t in i ? console.warn('There is a button with the key "' + t + '" registered already.') : r.push(i[t] = e)
        }, e = Prism.plugins.toolbar.hook = function (a) {
            var t = a.element.parentNode;
            if (t && /pre/i.test(t.nodeName) && !t.parentNode.classList.contains("code-toolbar")) {
                var e = document.createElement("div");
                e.classList.add("code-toolbar"), t.parentNode.insertBefore(e, t), e.appendChild(t);
                var o = document.createElement("div");
                o.classList.add("toolbar"), document.body.hasAttribute("data-toolbar-order") && (r = document.body.getAttribute("data-toolbar-order").split(",").map(function (t) {
                    return i[t] || n
                })), r.forEach(function (t) {
                    var e = t(a);
                    if (e) {
                        var n = document.createElement("div");
                        n.setAttribute('data-clipboard-action','copy');
                        n.setAttribute('data-clipboard-target','code');
                        n.classList.add("toolbar-item"), n.appendChild(e), o.appendChild(n)
                    }
                }), e.appendChild(o)
            }
        };
        t("label", function (t) {
            var e = t.element.parentNode;
            if (e && /pre/i.test(e.nodeName) && e.hasAttribute("data-label")) {
                var n, a, o = e.getAttribute("data-label");
                try {
                    a = document.querySelector("template#" + o)
                } catch (t) {
                }
                return a ? n = a.content : (e.hasAttribute("data-url") ? (n = document.createElement("a")).href = e.getAttribute("data-url") : n = document.createElement("span"), n.textContent = o), n
            }
        }), Prism.hooks.add("complete", e)
    }
}();
!function () {
    if (self.Prism && self.document && document.querySelectorAll && [].filter) {
        var d = [];
        t(function (t, e) {
            if (t && t.meta && t.data) {
                if (t.meta.status && 400 <= t.meta.status) return "Error: " + (t.data.message || t.meta.status);
                if ("string" == typeof t.data.content) return "function" == typeof atob ? atob(t.data.content.replace(/\s/g, "")) : "Your browser cannot decode base64"
            }
            return null
        }, "github"), t(function (t, e) {
            if (t && t.meta && t.data && t.data.files) {
                if (t.meta.status && 400 <= t.meta.status) return "Error: " + (t.data.message || t.meta.status);
                var n = t.data.files, a = e.getAttribute("data-filename");
                if (null == a) for (var r in n) if (n.hasOwnProperty(r)) {
                    a = r;
                    break
                }
                return void 0 !== n[a] ? n[a].content : "Error: unknown or missing gist file " + a
            }
            return null
        }, "gist"), t(function (t, e) {
            return t && t.node && "string" == typeof t.data ? t.data : null
        }, "bitbucket");
        var s = 0, l = "Loading…";
        Prism.plugins.jsonphighlight = {
            registerAdapter: t, removeAdapter: function (t) {
                if ("string" == typeof t && (t = n(t)), "function" == typeof t) {
                    var e = d.map(function (t) {
                        return t.adapter
                    }).indexOf(t);
                    0 <= e && d.splice(e, 1)
                }
            }, highlight: e
        }, e()
    }

    function t(t, e) {
        e = e || t.name, "function" != typeof t || n(t) || n(e) || d.push({adapter: t, name: e})
    }

    function n(t) {
        if ("function" == typeof t) {
            for (var e = 0; n = d[e++];) if (n.adapter.valueOf() === t.valueOf()) return n.adapter
        } else if ("string" == typeof t) {
            var n;
            for (e = 0; n = d[e++];) if (n.name === t) return n.adapter
        }
        return null
    }

    function e() {
        Array.prototype.slice.call(document.querySelectorAll("pre[data-jsonp]")).forEach(function (a) {
            a.textContent = "";
            var r = document.createElement("code");
            r.textContent = l, a.appendChild(r);
            var t = a.getAttribute("data-adapter"), o = null;
            if (t) {
                if ("function" != typeof window[t]) return void (r.textContent = "JSONP adapter function '" + t + "' doesn't exist");
                o = window[t]
            }
            var i = "prismjsonp" + s++, e = document.createElement("a"), n = e.href = a.getAttribute("data-jsonp");
            e.href += (e.search ? "&" : "?") + (a.getAttribute("data-callback") || "callback") + "=" + i;
            var u = setTimeout(function () {
                r.textContent === l && (r.textContent = "Timeout loading '" + n + "'")
            }, 5e3), f = document.createElement("script");
            f.src = e.href, window[i] = function (t) {
                document.head.removeChild(f), clearTimeout(u), delete window[i];
                var e = "";
                if (o) e = o(t, a); else for (var n in d) if (null !== (e = d[n].adapter(t, a))) break;
                null === e ? r.textContent = "Cannot parse response (perhaps you need an adapter function?)" : (r.textContent = e, Prism.highlightElement(r))
            }, document.head.appendChild(f)
        })
    }
}();
"undefined" != typeof self && !self.Prism || "undefined" != typeof global && !global.Prism || Prism.hooks.add("wrap", function (e) {
    "keyword" === e.type && e.classes.push("keyword-" + e.content)
});
!function () {
    if (("undefined" == typeof self || self.Prism) && self.document && Function.prototype.bind) {
        var r, s, o = {
                gradient: {
                    create: (r = {}, s = function (e) {
                        if (r[e]) return r[e];
                        var s = e.match(/^(\b|\B-[a-z]{1,10}-)((?:repeating-)?(?:linear|radial)-gradient)/), i = s && s[1],
                            t = s && s[2],
                            a = e.replace(/^(?:\b|\B-[a-z]{1,10}-)(?:repeating-)?(?:linear|radial)-gradient\(|\)$/g, "").split(/\s*,\s*/);
                        return 0 <= t.indexOf("linear") ? r[e] = function (e, s, i) {
                            var t = "180deg";
                            return /^(?:-?\d*\.?\d+(?:deg|rad)|to\b|top|right|bottom|left)/.test(i[0]) && (t = i.shift()).indexOf("to ") < 0 && (0 <= t.indexOf("top") ? t = 0 <= t.indexOf("left") ? "to bottom right" : 0 <= t.indexOf("right") ? "to bottom left" : "to bottom" : 0 <= t.indexOf("bottom") ? t = 0 <= t.indexOf("left") ? "to top right" : 0 <= t.indexOf("right") ? "to top left" : "to top" : 0 <= t.indexOf("left") ? t = "to right" : 0 <= t.indexOf("right") ? t = "to left" : e && (0 <= t.indexOf("deg") ? t = 90 - parseFloat(t) + "deg" : 0 <= t.indexOf("rad") && (t = Math.PI / 2 - parseFloat(t) + "rad"))), s + "(" + t + "," + i.join(",") + ")"
                        }(i, t, a) : 0 <= t.indexOf("radial") ? r[e] = function (e, s, i) {
                            if (i[0].indexOf("at") < 0) {
                                var t = "center", a = "ellipse", r = "farthest-corner";
                                if (/\bcenter|top|right|bottom|left\b|^\d+/.test(i[0]) && (t = i.shift().replace(/\s*-?\d+(?:rad|deg)\s*/, "")), /\bcircle|ellipse|closest|farthest|contain|cover\b/.test(i[0])) {
                                    var n = i.shift().split(/\s+/);
                                    !n[0] || "circle" !== n[0] && "ellipse" !== n[0] || (a = n.shift()), n[0] && (r = n.shift()), "cover" === r ? r = "farthest-corner" : "contain" === r && (r = "clothest-side")
                                }
                                return s + "(" + a + " " + r + " at " + t + "," + i.join(",") + ")"
                            }
                            return s + "(" + i.join(",") + ")"
                        }(0, t, a) : r[e] = t + "(" + a.join(",") + ")"
                    }, function () {
                        new Prism.plugins.Previewer("gradient", function (e) {
                            return this.firstChild.style.backgroundImage = "", this.firstChild.style.backgroundImage = s(e), !!this.firstChild.style.backgroundImage
                        }, "*", function () {
                            this._elt.innerHTML = "<div></div>"
                        })
                    }),
                    tokens: {
                        gradient: {
                            pattern: /(?:\b|\B-[a-z]{1,10}-)(?:repeating-)?(?:linear|radial)-gradient\((?:(?:rgb|hsl)a?\(.+?\)|[^\)])+\)/gi,
                            inside: {function: /[\w-]+(?=\()/, punctuation: /[(),]/}
                        }
                    },
                    languages: {
                        css: !0,
                        less: !0,
                        sass: [{
                            lang: "sass",
                            before: "punctuation",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["variable-line"]
                        }, {
                            lang: "sass",
                            before: "punctuation",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["property-line"]
                        }],
                        scss: !0,
                        stylus: [{
                            lang: "stylus",
                            before: "func",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["property-declaration"].inside
                        }, {
                            lang: "stylus",
                            before: "func",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["variable-declaration"].inside
                        }]
                    }
                }, angle: {
                    create: function () {
                        new Prism.plugins.Previewer("angle", function (e) {
                            var s, i, t = parseFloat(e), a = e.match(/[a-z]+$/i);
                            if (!t || !a) return !1;
                            switch (a = a[0]) {
                                case"deg":
                                    s = 360;
                                    break;
                                case"grad":
                                    s = 400;
                                    break;
                                case"rad":
                                    s = 2 * Math.PI;
                                    break;
                                case"turn":
                                    s = 1
                            }
                            return i = 100 * t / s, i %= 100, this[(t < 0 ? "set" : "remove") + "Attribute"]("data-negative", ""), this.querySelector("circle").style.strokeDasharray = Math.abs(i) + ",500", !0
                        }, "*", function () {
                            this._elt.innerHTML = '<svg viewBox="0 0 64 64"><circle r="16" cy="32" cx="32"></circle></svg>'
                        })
                    },
                    tokens: {angle: /(?:\b|\B-|(?=\B\.))\d*\.?\d+(?:deg|g?rad|turn)\b/i},
                    languages: {
                        css: !0,
                        less: !0,
                        markup: {
                            lang: "markup",
                            before: "punctuation",
                            inside: "inside",
                            root: Prism.languages.markup && Prism.languages.markup.tag.inside["attr-value"]
                        },
                        sass: [{
                            lang: "sass",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["property-line"]
                        }, {
                            lang: "sass",
                            before: "operator",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["variable-line"]
                        }],
                        scss: !0,
                        stylus: [{
                            lang: "stylus",
                            before: "func",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["property-declaration"].inside
                        }, {
                            lang: "stylus",
                            before: "func",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["variable-declaration"].inside
                        }]
                    }
                }, color: {
                    create: function () {
                        new Prism.plugins.Previewer("color", function (e) {
                            return this.style.backgroundColor = "", this.style.backgroundColor = e, !!this.style.backgroundColor
                        })
                    },
                    tokens: {
                        color: {
                            pattern: /\B#(?:[0-9a-f]{3}){1,2}\b|\b(?:rgb|hsl)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:rgb|hsl)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B|\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGray|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGray|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGray|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gray|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGray|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGray|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGray|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\b/i,
                            inside: {function: /[\w-]+(?=\()/, punctuation: /[(),]/}
                        }
                    },
                    languages: {
                        css: !0,
                        less: !0,
                        markup: {
                            lang: "markup",
                            before: "punctuation",
                            inside: "inside",
                            root: Prism.languages.markup && Prism.languages.markup.tag.inside["attr-value"]
                        },
                        sass: [{
                            lang: "sass",
                            before: "punctuation",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["variable-line"]
                        }, {
                            lang: "sass",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["property-line"]
                        }],
                        scss: !0,
                        stylus: [{
                            lang: "stylus",
                            before: "hexcode",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["property-declaration"].inside
                        }, {
                            lang: "stylus",
                            before: "hexcode",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["variable-declaration"].inside
                        }]
                    }
                }, easing: {
                    create: function () {
                        new Prism.plugins.Previewer("easing", function (e) {
                            var s = (e = {
                                linear: "0,0,1,1",
                                ease: ".25,.1,.25,1",
                                "ease-in": ".42,0,1,1",
                                "ease-out": "0,0,.58,1",
                                "ease-in-out": ".42,0,.58,1"
                            }[e] || e).match(/-?\d*\.?\d+/g);
                            if (4 !== s.length) return !1;
                            s = s.map(function (e, s) {
                                return 100 * (s % 2 ? 1 - e : e)
                            }), this.querySelector("path").setAttribute("d", "M0,100 C" + s[0] + "," + s[1] + ", " + s[2] + "," + s[3] + ", 100,0");
                            var i = this.querySelectorAll("line");
                            return i[0].setAttribute("x2", s[0]), i[0].setAttribute("y2", s[1]), i[1].setAttribute("x2", s[2]), i[1].setAttribute("y2", s[3]), !0
                        }, "*", function () {
                            this._elt.innerHTML = '<svg viewBox="-20 -20 140 140" width="100" height="100"><defs><marker id="prism-previewer-easing-marker" viewBox="0 0 4 4" refX="2" refY="2" markerUnits="strokeWidth"><circle cx="2" cy="2" r="1.5" /></marker></defs><path d="M0,100 C20,50, 40,30, 100,0" /><line x1="0" y1="100" x2="20" y2="50" marker-start="url(' + location.href + '#prism-previewer-easing-marker)" marker-end="url(' + location.href + '#prism-previewer-easing-marker)" /><line x1="100" y1="0" x2="40" y2="30" marker-start="url(' + location.href + '#prism-previewer-easing-marker)" marker-end="url(' + location.href + '#prism-previewer-easing-marker)" /></svg>'
                        })
                    },
                    tokens: {
                        easing: {
                            pattern: /\bcubic-bezier\((?:-?\d*\.?\d+,\s*){3}-?\d*\.?\d+\)\B|\b(?:linear|ease(?:-in)?(?:-out)?)(?=\s|[;}]|$)/i,
                            inside: {function: /[\w-]+(?=\()/, punctuation: /[(),]/}
                        }
                    },
                    languages: {
                        css: !0,
                        less: !0,
                        sass: [{
                            lang: "sass",
                            inside: "inside",
                            before: "punctuation",
                            root: Prism.languages.sass && Prism.languages.sass["variable-line"]
                        }, {
                            lang: "sass",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["property-line"]
                        }],
                        scss: !0,
                        stylus: [{
                            lang: "stylus",
                            before: "hexcode",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["property-declaration"].inside
                        }, {
                            lang: "stylus",
                            before: "hexcode",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["variable-declaration"].inside
                        }]
                    }
                }, time: {
                    create: function () {
                        new Prism.plugins.Previewer("time", function (e) {
                            var s = parseFloat(e), i = e.match(/[a-z]+$/i);
                            return !(!s || !i) && (i = i[0], this.querySelector("circle").style.animationDuration = 2 * s + i, !0)
                        }, "*", function () {
                            this._elt.innerHTML = '<svg viewBox="0 0 64 64"><circle r="16" cy="32" cx="32"></circle></svg>'
                        })
                    },
                    tokens: {time: /(?:\b|\B-|(?=\B\.))\d*\.?\d+m?s\b/i},
                    languages: {
                        css: !0,
                        less: !0,
                        markup: {
                            lang: "markup",
                            before: "punctuation",
                            inside: "inside",
                            root: Prism.languages.markup && Prism.languages.markup.tag.inside["attr-value"]
                        },
                        sass: [{
                            lang: "sass",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["property-line"]
                        }, {
                            lang: "sass",
                            before: "operator",
                            inside: "inside",
                            root: Prism.languages.sass && Prism.languages.sass["variable-line"]
                        }],
                        scss: !0,
                        stylus: [{
                            lang: "stylus",
                            before: "hexcode",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["property-declaration"].inside
                        }, {
                            lang: "stylus",
                            before: "hexcode",
                            inside: "rest",
                            root: Prism.languages.stylus && Prism.languages.stylus["variable-declaration"].inside
                        }]
                    }
                }
            }, i = /(?:^|\s)token(?=$|\s)/, e = /(?:^|\s)active(?=$|\s)/g, t = /(?:^|\s)flipped(?=$|\s)/g,
            n = function (e, s, i, t) {
                this._elt = null, this._type = e, this._clsRegexp = RegExp("(?:^|\\s)" + e + "(?=$|\\s)"), this._token = null, this.updater = s, this._mouseout = this.mouseout.bind(this), this.initializer = t;
                var a = this;
                i || (i = ["*"]), Array.isArray(i) || (i = [i]), i.forEach(function (e) {
                    "string" != typeof e && (e = e.lang), n.byLanguages[e] || (n.byLanguages[e] = []), n.byLanguages[e].indexOf(a) < 0 && n.byLanguages[e].push(a)
                }), n.byType[e] = this
            };
        for (var a in n.prototype.init = function () {
            this._elt || (this._elt = document.createElement("div"), this._elt.className = "prism-previewer prism-previewer-" + this._type, document.body.appendChild(this._elt), this.initializer && this.initializer())
        }, n.prototype.isDisabled = function (e) {
            do {
                if (e.hasAttribute && e.hasAttribute("data-previewers")) return -1 === (e.getAttribute("data-previewers") || "").split(/\s+/).indexOf(this._type)
            } while (e = e.parentNode);
            return !1
        }, n.prototype.check = function (e) {
            if (!i.test(e.className) || !this.isDisabled(e)) {
                do {
                    if (i.test(e.className) && this._clsRegexp.test(e.className)) break
                } while (e = e.parentNode);
                e && e !== this._token && (this._token = e, this.show())
            }
        }, n.prototype.mouseout = function () {
            this._token.removeEventListener("mouseout", this._mouseout, !1), this._token = null, this.hide()
        }, n.prototype.show = function () {
            if (this._elt || this.init(), this._token) if (this.updater.call(this._elt, this._token.textContent)) {
                this._token.addEventListener("mouseout", this._mouseout, !1);
                var e = function (e) {
                    var s = e.getBoundingClientRect(), i = s.left, t = s.top,
                        a = document.documentElement.getBoundingClientRect();
                    return i -= a.left, {
                        top: t -= a.top,
                        right: innerWidth - i - s.width,
                        bottom: innerHeight - t - s.height,
                        left: i,
                        width: s.width,
                        height: s.height
                    }
                }(this._token);
                this._elt.className += " active", 0 < e.top - this._elt.offsetHeight ? (this._elt.className = this._elt.className.replace(t, ""), this._elt.style.top = e.top + "px", this._elt.style.bottom = "") : (this._elt.className += " flipped", this._elt.style.bottom = e.bottom + "px", this._elt.style.top = ""), this._elt.style.left = e.left + Math.min(200, e.width / 2) + "px"
            } else this.hide()
        }, n.prototype.hide = function () {
            this._elt.className = this._elt.className.replace(e, "")
        }, n.byLanguages = {}, n.byType = {}, n.initEvents = function (e, s) {
            var i = [];
            n.byLanguages[s] && (i = i.concat(n.byLanguages[s])), n.byLanguages["*"] && (i = i.concat(n.byLanguages["*"])), e.addEventListener("mouseover", function (e) {
                var s = e.target;
                i.forEach(function (e) {
                    e.check(s)
                })
            }, !1)
        }, Prism.plugins.Previewer = n, Prism.hooks.add("before-highlight", function (r) {
            for (var n in o) {
                var l = o[n].languages;
                if (r.language && l[r.language] && !l[r.language].initialized) {
                    var e = l[r.language];
                    Array.isArray(e) || (e = [e]), e.forEach(function (e) {
                        var s, i, t, a;
                        e = (!0 === e ? (s = "important", i = r.language) : (s = e.before || "important", i = e.inside || e.lang, t = e.root || Prism.languages, a = e.skip), r.language), !a && Prism.languages[e] && (Prism.languages.insertBefore(i, s, o[n].tokens, t), r.grammar = Prism.languages[e], l[r.language] = {initialized: !0})
                    })
                }
            }
        }), Prism.hooks.add("after-highlight", function (e) {
            (n.byLanguages["*"] || n.byLanguages[e.language]) && n.initEvents(e.element, e.language)
        }), o) o[a].create()
    }
}();
!function () {
    if ("undefined" != typeof self && self.Prism && self.document && document.createElement) {
        var i = {
            javascript: "clike",
            actionscript: "javascript",
            arduino: "cpp",
            aspnet: ["markup", "csharp"],
            bison: "c",
            c: "clike",
            csharp: "clike",
            cpp: "c",
            coffeescript: "javascript",
            crystal: "ruby",
            "css-extras": "css",
            d: "clike",
            dart: "clike",
            django: "markup-templating",
            ejs: ["javascript", "markup-templating"],
            erb: ["ruby", "markup-templating"],
            fsharp: "clike",
            flow: "javascript",
            glsl: "clike",
            gml: "clike",
            go: "clike",
            groovy: "clike",
            haml: "ruby",
            handlebars: "markup-templating",
            haxe: "clike",
            java: "clike",
            javadoc: ["markup", "java", "javadoclike"],
            jolie: "clike",
            jsdoc: ["javascript", "javadoclike"],
            "js-extras": "javascript",
            jsonp: "json",
            json5: "json",
            kotlin: "clike",
            less: "css",
            markdown: "markup",
            "markup-templating": "markup",
            n4js: "javascript",
            nginx: "clike",
            objectivec: "c",
            opencl: "cpp",
            parser: "markup",
            php: ["clike", "markup-templating"],
            phpdoc: ["php", "javadoclike"],
            "php-extras": "php",
            plsql: "sql",
            processing: "clike",
            protobuf: "clike",
            pug: ["markup", "javascript"],
            qore: "clike",
            jsx: ["markup", "javascript"],
            tsx: ["jsx", "typescript"],
            reason: "clike",
            ruby: "clike",
            sass: "css",
            scss: "css",
            scala: "java",
            smarty: "markup-templating",
            soy: "markup-templating",
            swift: "clike",
            tap: "yaml",
            textile: "markup",
            tt2: ["clike", "markup-templating"],
            twig: "markup",
            typescript: "javascript",
            "t4-cs": ["t4-templating", "csharp"],
            "t4-vb": ["t4-templating", "visual-basic"],
            vala: "clike",
            vbnet: "basic",
            velocity: "markup",
            wiki: "markup",
            xeora: "markup",
            xquery: "markup"
        }, l = {
            html: "markup",
            xml: "markup",
            svg: "markup",
            mathml: "markup",
            js: "javascript",
            adoc: "asciidoc",
            shell: "bash",
            rbnf: "bnf",
            dotnet: "csharp",
            coffee: "coffeescript",
            jinja2: "django",
            dockerfile: "docker",
            gamemakerlanguage: "gml",
            hs: "haskell",
            emacs: "lisp",
            elisp: "lisp",
            "emacs-lisp": "lisp",
            md: "markdown",
            n4jsd: "n4js",
            objectpascal: "pascal",
            py: "python",
            rb: "ruby",
            ts: "typescript",
            t4: "t4-cs",
            vb: "visual-basic",
            xeoracube: "xeora",
            yml: "yaml"
        }, n = {}, a = document.getElementsByTagName("script"), e = "components/";
        if ((a = a[a.length - 1]).hasAttribute("data-autoloader-path")) {
            var c = a.getAttribute("data-autoloader-path").trim();
            0 < c.length && !/^[a-z]+:\/\//i.test(a.src) && (e = c.replace(/\/?$/, "/"))
        } else /[\w-]+\.js$/.test(a.src) && (e = a.src.replace(/[\w-]+\.js$/, "components/"));
        var p = Prism.plugins.autoloader = {languages_path: e, use_minified: !0}, o = function (a, e, c) {
            "string" == typeof a && (a = [a]);
            var s = 0, t = a.length, r = function () {
                s < t ? u(a[s], function () {
                    s++, r()
                }, function () {
                    c && c(a[s])
                }) : s === t && e && e(a)
            };
            r()
        }, u = function (e, c, s) {
            var t = 0 <= e.indexOf("!");
            e = e.replace("!", "");
            var a = function () {
                var a = n[e];
                if (a || (a = n[e] = {}), c && (a.success_callbacks || (a.success_callbacks = []), a.success_callbacks.push(c)), s && (a.error_callbacks || (a.error_callbacks = []), a.error_callbacks.push(s)), !t && Prism.languages[e]) m(e); else if (!t && a.error) k(e); else if (t || !a.loading) {
                    a.loading = !0, function (a, e, c) {
                        var s = document.createElement("script");
                        s.src = a, s.async = !0, s.onload = function () {
                            document.body.removeChild(s), e && e()
                        }, s.onerror = function () {
                            document.body.removeChild(s), c && c()
                        }, document.body.appendChild(s)
                    }(function (a) {
                        return p.languages_path + "prism-" + a + (p.use_minified ? ".min" : "") + ".js"
                    }(e), function () {
                        a.loading = !1, m(e)
                    }, function () {
                        a.loading = !1, a.error = !0, k(e)
                    })
                }
            }, r = i[e = l[e] || e];
            r && r.length ? o(r, a) : a()
        }, m = function (e) {
            n[e] && n[e].success_callbacks && n[e].success_callbacks.length && n[e].success_callbacks.forEach(function (a) {
                a(e)
            })
        }, k = function (e) {
            n[e] && n[e].error_callbacks && n[e].error_callbacks.length && n[e].error_callbacks.forEach(function (a) {
                a(e)
            })
        };
        Prism.hooks.add("complete", function (a) {
            a.element && a.language && !a.grammar && "none" !== a.language && function (a, e) {
                a in l && (a = l[a]);
                var c = n[a];
                c || (c = n[a] = {});
                var s = e.getAttribute("data-dependencies");
                !s && e.parentNode && "pre" === e.parentNode.tagName.toLowerCase() && (s = e.parentNode.getAttribute("data-dependencies")), s = s ? s.split(/\s*,\s*/g) : [], o(s, function () {
                    u(a, function () {
                        Prism.highlightElement(e)
                    })
                })
            }(a.language, a.element)
        })
    }
}();
"undefined" != typeof self && self.Prism && self.document && Prism.languages.markup && (Prism.plugins.UnescapedMarkup = !0, Prism.hooks.add("before-highlightall", function (e) {
    e.selector += ", [class*='lang-'] script[type='text/plain'], [class*='language-'] script[type='text/plain'], script[type='text/plain'][class*='lang-'], script[type='text/plain'][class*='language-']"
}), Prism.hooks.add("before-sanity-check", function (t) {
    if ((t.element.matches || t.element.msMatchesSelector).call(t.element, "script[type='text/plain']")) {
        var e = document.createElement("code");
        return (a = document.createElement("pre")).className = e.className = t.element.className, t.element.dataset && Object.keys(t.element.dataset).forEach(function (e) {
            Object.prototype.hasOwnProperty.call(t.element.dataset, e) && (a.dataset[e] = t.element.dataset[e])
        }), t.code = t.code.replace(/&lt;\/script(>|&gt;)/gi, "<\/script>"), e.textContent = t.code, a.appendChild(e), t.element.parentNode.replaceChild(a, t.element), void (t.element = e)
    }
    var a = t.element.parentNode;
    !t.code && a && "pre" == a.nodeName.toLowerCase() && t.element.childNodes.length && "#comment" == t.element.childNodes[0].nodeName && (t.element.textContent = t.code = t.element.childNodes[0].textContent)
}));
!function () {
    var i = Object.assign || function (e, n) {
        for (var t in n) n.hasOwnProperty(t) && (e[t] = n[t]);
        return e
    };

    function e(e) {
        this.defaults = i({}, e)
    }

    function l(e) {
        for (var n = 0, t = 0; t < e.length; ++t) e.charCodeAt(t) == "\t".charCodeAt(0) && (n += 3);
        return e.length + n
    }

    e.prototype = {
        setDefaults: function (e) {
            this.defaults = i(this.defaults, e)
        }, normalize: function (e, n) {
            for (var t in n = i(this.defaults, n)) {
                var r = t.replace(/-(\w)/g, function (e, n) {
                    return n.toUpperCase()
                });
                "normalize" !== t && "setDefaults" !== r && n[t] && this[r] && (e = this[r].call(this, e, n[t]))
            }
            return e
        }, leftTrim: function (e) {
            return e.replace(/^\s+/, "")
        }, rightTrim: function (e) {
            return e.replace(/\s+$/, "")
        }, tabsToSpaces: function (e, n) {
            return n = 0 | n || 4, e.replace(/\t/g, new Array(++n).join(" "))
        }, spacesToTabs: function (e, n) {
            return n = 0 | n || 4, e.replace(RegExp(" {" + n + "}", "g"), "\t")
        }, removeTrailing: function (e) {
            return e.replace(/\s*?$/gm, "")
        }, removeInitialLineFeed: function (e) {
            return e.replace(/^(?:\r?\n|\r)/, "")
        }, removeIndent: function (e) {
            var n = e.match(/^[^\S\n\r]*(?=\S)/gm);
            return n && n[0].length ? (n.sort(function (e, n) {
                return e.length - n.length
            }), n[0].length ? e.replace(RegExp("^" + n[0], "gm"), "") : e) : e
        }, indent: function (e, n) {
            return e.replace(/^[^\S\n\r]*(?=\S)/gm, new Array(++n).join("\t") + "$&")
        }, breakLines: function (e, n) {
            n = !0 === n ? 80 : 0 | n || 80;
            for (var t = e.split("\n"), r = 0; r < t.length; ++r) if (!(l(t[r]) <= n)) {
                for (var i = t[r].split(/(\s+)/g), o = 0, a = 0; a < i.length; ++a) {
                    var s = l(i[a]);
                    n < (o += s) && (i[a] = "\n" + i[a], o = s)
                }
                t[r] = i.join("")
            }
            return t.join("\n")
        }
    }, "undefined" != typeof module && module.exports && (module.exports = e), "undefined" != typeof Prism && (Prism.plugins.NormalizeWhitespace = new e({
        "remove-trailing": !0,
        "remove-indent": !0,
        "left-trim": !0,
        "right-trim": !0
    }), Prism.hooks.add("before-sanity-check", function (e) {
        var n = Prism.plugins.NormalizeWhitespace;
        if (!e.settings || !1 !== e.settings["whitespace-normalization"]) if (e.element && e.element.parentNode || !e.code) {
            var t = e.element.parentNode, r = /(?:^|\s)no-whitespace-normalization(?:\s|$)/;
            if (e.code && t && "pre" === t.nodeName.toLowerCase() && !r.test(t.className) && !r.test(e.element.className)) {
                for (var i = t.childNodes, o = "", a = "", s = !1, l = 0; l < i.length; ++l) {
                    var c = i[l];
                    c == e.element ? s = !0 : "#text" === c.nodeName && (s ? a += c.nodeValue : o += c.nodeValue, t.removeChild(c), --l)
                }
                if (e.element.children.length && Prism.plugins.KeepMarkup) {
                    var u = o + e.element.innerHTML + a;
                    e.element.innerHTML = n.normalize(u, e.settings), e.code = e.element.textContent
                } else e.code = o + e.code + a, e.code = n.normalize(e.code, e.settings)
            }
        } else e.code = n.normalize(e.code, e.settings)
    }))
}();
!function (e, s) {
    void 0 !== e && e.Prism && e.document && s.createRange && (Prism.plugins.KeepMarkup = !0, Prism.hooks.add("before-highlight", function (e) {
        if (e.element.children.length) {
            var a = 0, s = [], p = function (e, n) {
                var o = {};
                n || (o.clone = e.cloneNode(!1), o.posOpen = a, s.push(o));
                for (var t = 0, d = e.childNodes.length; t < d; t++) {
                    var r = e.childNodes[t];
                    1 === r.nodeType ? p(r) : 3 === r.nodeType && (a += r.data.length)
                }
                n || (o.posClose = a)
            };
            p(e.element, !0), s && s.length && (e.keepMarkup = s)
        }
    }), Prism.hooks.add("after-highlight", function (n) {
        if (n.keepMarkup && n.keepMarkup.length) {
            var a = function (e, n) {
                for (var o = 0, t = e.childNodes.length; o < t; o++) {
                    var d = e.childNodes[o];
                    if (1 === d.nodeType) {
                        if (!a(d, n)) return !1
                    } else 3 === d.nodeType && (!n.nodeStart && n.pos + d.data.length > n.node.posOpen && (n.nodeStart = d, n.nodeStartPos = n.node.posOpen - n.pos), n.nodeStart && n.pos + d.data.length >= n.node.posClose && (n.nodeEnd = d, n.nodeEndPos = n.node.posClose - n.pos), n.pos += d.data.length);
                    if (n.nodeStart && n.nodeEnd) {
                        var r = s.createRange();
                        return r.setStart(n.nodeStart, n.nodeStartPos), r.setEnd(n.nodeEnd, n.nodeEndPos), n.node.clone.appendChild(r.extractContents()), r.insertNode(n.node.clone), r.detach(), !1
                    }
                }
                return !0
            };
            n.keepMarkup.forEach(function (e) {
                a(n.element, {node: e, pos: 0})
            }), n.highlightedCode = n.element.innerHTML
        }
    }))
}(self, document);
!function () {
    if ("undefined" != typeof self && self.Prism && self.document) if (Prism.plugins.toolbar) {
        var r = {
            html: "HTML",
            xml: "XML",
            svg: "SVG",
            mathml: "MathML",
            css: "CSS",
            clike: "C-like",
            js: "JavaScript",
            abap: "ABAP",
            abnf: "Augmented Backus–Naur form",
            apacheconf: "Apache Configuration",
            apl: "APL",
            arff: "ARFF",
            asciidoc: "AsciiDoc",
            adoc: "AsciiDoc",
            asm6502: "6502 Assembly",
            aspnet: "ASP.NET (C#)",
            autohotkey: "AutoHotkey",
            autoit: "AutoIt",
            shell: "Bash",
            basic: "BASIC",
            bnf: "Backus–Naur form",
            rbnf: "Routing Backus–Naur form",
            csharp: "C#",
            dotnet: "C#",
            cpp: "C++",
            cil: "CIL",
            coffee: "CoffeeScript",
            cmake: "CMake",
            csp: "Content-Security-Policy",
            "css-extras": "CSS Extras",
            django: "Django/Jinja2",
            jinja2: "Django/Jinja2",
            dockerfile: "Docker",
            ebnf: "Extended Backus–Naur form",
            ejs: "EJS",
            erb: "ERB",
            fsharp: "F#",
            gcode: "G-code",
            gedcom: "GEDCOM",
            glsl: "GLSL",
            gml: "GameMaker Language",
            gamemakerlanguage: "GameMaker Language",
            graphql: "GraphQL",
            hs: "Haskell",
            hcl: "HCL",
            http: "HTTP",
            hpkp: "HTTP Public-Key-Pins",
            hsts: "HTTP Strict-Transport-Security",
            ichigojam: "IchigoJam",
            inform7: "Inform 7",
            javadoc: "JavaDoc",
            javadoclike: "JavaDoc-like",
            javastacktrace: "Java stack trace",
            jsdoc: "JSDoc",
            "js-extras": "JS Extras",
            json: "JSON",
            jsonp: "JSONP",
            json5: "JSON5",
            latex: "LaTeX",
            emacs: "Lisp",
            elisp: "Lisp",
            "emacs-lisp": "Lisp",
            lolcode: "LOLCODE",
            md: "Markdown",
            "markup-templating": "Markup templating",
            matlab: "MATLAB",
            mel: "MEL",
            n1ql: "N1QL",
            n4js: "N4JS",
            n4jsd: "N4JS",
            "nand2tetris-hdl": "Nand To Tetris HDL",
            nasm: "NASM",
            nginx: "nginx",
            nsis: "NSIS",
            objectivec: "Objective-C",
            ocaml: "OCaml",
            opencl: "OpenCL",
            parigp: "PARI/GP",
            objectpascal: "Object Pascal",
            php: "PHP",
            phpdoc: "PHPDoc",
            "php-extras": "PHP Extras",
            plsql: "PL/SQL",
            powershell: "PowerShell",
            properties: ".properties",
            protobuf: "Protocol Buffers",
            py: "Python",
            q: "Q (kdb+ database)",
            jsx: "React JSX",
            tsx: "React TSX",
            renpy: "Ren'py",
            rest: "reST (reStructuredText)",
            rb: "Ruby",
            sas: "SAS",
            sass: "Sass (Sass)",
            scss: "Sass (Scss)",
            sql: "SQL",
            soy: "Soy (Closure Template)",
            tap: "TAP",
            toml: "TOML",
            tt2: "Template Toolkit 2",
            ts: "TypeScript",
            "t4-cs": "T4 Text Templates (C#)",
            t4: "T4 Text Templates (C#)",
            "t4-vb": "T4 Text Templates (VB)",
            "t4-templating": "T4 templating",
            vbnet: "VB.Net",
            vhdl: "VHDL",
            vim: "vim",
            "visual-basic": "Visual Basic",
            vb: "Visual Basic",
            wasm: "WebAssembly",
            wiki: "Wiki markup",
            xeoracube: "XeoraCube",
            xojo: "Xojo (REALbasic)",
            xquery: "XQuery",
            yaml: "YAML",
            yml: "YAML"
        };
        Prism.plugins.toolbar.registerButton("show-language", function (e) {
            var a = e.element.parentNode;
            if (a && /pre/i.test(a.nodeName)) {
                var s,
                    t = a.getAttribute("data-language") || r[e.language] || ((s = e.language) ? (s.substring(0, 1).toUpperCase() + s.substring(1)).replace(/s(?=cript)/, "S") : s);
                if (t) {
                    var o = document.createElement("span");
                    return o.textContent = t, o
                }
            }
        })
    } else console.warn("Show Languages plugin loaded before Toolbar plugin.")
}();
